home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Toolbox / Visual Basic Toolbox (P.I.E.)(1996).ISO / dll_dbas / arraycb / array.c < prev    next >
C/C++ Source or Header  |  1994-03-09  |  4KB  |  126 lines
  1. //********************************************************
  2. // ARRAY.C - Visual Basic Array Manipulation DLL Source
  3. // Author: Chuck Benedict, CIS 73672,1662
  4. // Date: 3/9/1994
  5. // Usage Information:
  6. //        You have my permission to use this code in whatever
  7. //        way you see fit on the condition that you agree not
  8. //        to hold me responsible for anything either positive
  9. //        or negative that results due to its usage.  If you
  10. //        find the DLL or the source code useful, I will
  11. //        gladly accept donations ($10 would be nice)!
  12. //        My address: 1503 Clear Valley
  13. //                        Houston, TX  77014
  14. // Revisions:
  15. //    V0.1 - DeleteArrayIndex function created
  16. //********************************************************
  17. #include "windows.h"
  18. #include "vbapi.h"
  19. #include <string.h>
  20.  
  21. int FAR PASCAL LibMain (
  22.     HANDLE hInstance,            // DLLs Module Handle
  23.     USHORT uDataSeg,            // data segment selector
  24.     USHORT cbHeapSize,        // initial heap size
  25.     LPSTR  lpszCmdLine)        // command line arguments?
  26.     {
  27.  
  28.     // Unlock the data segment that LibEntry locked for us
  29.     UnlockData (0);
  30.     return TRUE;                        // true to succeed
  31.     }
  32.  
  33. void FAR MyMemmove(
  34.    char __huge  *hpSource,        // Source buffer pointer
  35.    char __huge  *hpDest,          // Destination buffer pointer
  36.    unsigned long  lCount)         // Count of bytes to move
  37. {
  38.  
  39.    UINT         ucount;           // Temporary short int
  40.    BOOL         bReverse = FALSE; // Bottom up?
  41.  
  42. // If we are moving less than 64K, we can do it all in one call.
  43.    if (HIWORD(lCount) == 0) {
  44.       _fmemmove(hpDest, hpSource, LOWORD(lCount));
  45.  
  46.       return;
  47.    }
  48.  
  49. // We are now dealing with >64K of data. If the destination 
  50. // is lower in memory than the source, we can repetitively 
  51. // copy 64K blocks from the top of each block. If the destination
  52. // is higher in memory than the source, we must repetitively move 
  53. // 64K blocks from the bottom of the source and destination to
  54. // prevent overwriting the source. We start by adjusting the source
  55. // and destination pointers to point at the last 64K chunk in the
  56.  
  57. // block and set a flag (bReverse). After each block move, we move
  58. // the source and destination pointers up or down appropriately.
  59.  
  60.    if (hpDest > hpSource) {
  61.       hpSource += (lCount - 65535);  
  62.       hpDest += (lCount - 65535);
  63.       bReverse = TRUE;
  64.    }
  65.    while (TRUE) {
  66.       if (HIWORD(lCount))
  67.          ucount = 65535;       // >64K left; set ucount to 64K
  68.       else
  69.          ucount = LOWORD(lCount);
  70.       _fmemmove(hpDest, hpSource, ucount);
  71.  
  72.       lCount -= ucount;        // Reduce the amount left to move
  73.       if (lCount == 0)
  74.          return;               // All done; return
  75.       if (bReverse) {          // Update source/destination pointers
  76.          if (HIWORD(lCount)) {
  77.             hpDest -= ucount;
  78.             hpSource -= ucount;
  79.          } else {
  80.             hpDest -= LOWORD(lCount);
  81.             hpSource -= LOWORD(lCount);
  82.          }
  83.       } else {
  84.          hpDest += ucount;
  85.  
  86.          hpSource += ucount;
  87.       }
  88.    }
  89.    return;
  90. }
  91.  
  92. int FAR PASCAL _export DeleteArrayIndex(
  93.     HAD hAD,
  94.     SHORT Index)
  95. {
  96.     ULONG lBounds;                    // define working variables
  97.     SHORT arIndex[1];
  98.     char __huge *source;
  99.     char __huge *dest;
  100.     ULONG lCount;
  101.  
  102. // we can only do one-dimentional arrays for now
  103.     if (VBArrayIndexCount(hAD) != 1)
  104.         return 0;
  105.  
  106. // check to make sure index is within range of array boundries
  107.     lBounds = VBArrayBounds(hAD, 1);
  108.     if (Index < LOBOUND(lBounds) || Index > HIBOUND(lBounds))
  109.         return 0;
  110.  
  111. // check if the Index passed = upper bound
  112.     if (Index == HIBOUND(lBounds))
  113.         return -1;
  114.  
  115. // now, get source and dest address: source will be Index + 1,
  116. // dest will be Index
  117.     arIndex[0] = Index + 1;
  118.     source = (char __huge *) VBArrayElement(hAD, 1, arIndex);
  119.    arIndex[0] = Index;
  120.     dest = (char __huge *) VBArrayElement(hAD, 1, arIndex);
  121.     lCount = (HIBOUND(lBounds) - Index) * VBArrayElemSize(hAD);
  122.  
  123. // move the memory
  124.     MyMemmove(source, dest, lCount);
  125.     return -1;
  126. }